﻿#define  _CRT_SECURE_NO_WARNINGS 1

#include<iostream>
using namespace std;

//class Stack
//{
//public:
//	// 成员函数
//	void Init(int capacity = 4)
//	{
//		_a = nullptr;  // malloc
//		_top = 0;
//		_capacity = capacity;
//	}
//
//	void Push(int x)
//	{
//
//	}
//
//private:
//	// 成员变量
//	int* _a;
//	int _top;
//	int _capacity;
//
//};
//
//int main()
//{
//	Stack s1;
//	s1.Init();
//	s1.Push(1);
//	s1.Push(2);
//	s1.Push(3);
//
//	return 0;
//}

//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//private:
//	// 为了区分成员变量，⼀般习惯上成员变量 
//	// 会加⼀个特殊标识，如_ 或者 m开头 
//	int _year; // year_ m_year
//	int _month;
//	int _day;
//};
//int main()
//{
//	Date d;
//	d.Init(2024, 3, 31);
//	return 0;
//}

//class Stack
//{
//
//private:
//	//下方全为私有限制
//	void Init(int capacity = 4)
//	{
//		_a = nullptr;  // malloc
//		_top = 0;
//		_capacity = capacity;
//	}
//
//	void Push(int x)
//	{
//
//	}
//
//	int* _a;
//	int _top;
//	int _capacity;
//
//};

//  驼峰法  StackInit 类型 函数， 单词首字母大写开头 + 单词首字母大写
//         initCapacity   变量    单词首字符小写开头+单词首字母大写
//以及：
//        stack_init
//        init_capacity

//typedef struct A
//{
//	void func()
//	{}
//
//	int a1;
//	int a2;
//}AA;
//
//// 升级为类
//struct B
//{
//	void Init()
//	{}
//
//private:
//	int b1;
//	int b2;
//};
//
//struct ListNode
//{
//	int val;
//	//struct ListNode* next;
//	ListNode* next;
//};
//
//class Stack
//{
//public:
//	// 成员函数
//	void Init(int capacity = 4)
//	{
//		_a = nullptr;  // malloc
//		_top = 0;
//		_capacity = capacity;
//	}
//
//	void Push(int x)
//	{}
//
//private:
//	// 成员变量
//	int* _a;
//	int _top;
//	int _capacity;
//
//};
//
//int main()
//{
//	struct A aa1;
//	AA aa2;
//
//	B bb1;
//	bb1.Init();
//
//	Stack s1;
//	s1.Init();
//	s1.Push(1);
//	s1.Push(2);
//	s1.Push(3);
//	
//	s1.top++;//错误使用
//	
//	return 0;
//}

//class Stack
//{
//public:
//	// 成员函数 
//	void Init(int n = 4);
//private:
//	// 成员变量 
//	int* array;
//	size_t capacity;
//	size_t top;
//};
//// 声明和定义分离，需要指定类域 
//void Stack::Init(int n)
//{
//	array = (int*)malloc(sizeof(int) * n);
//	if (nullptr == array)
//	{
//		perror("malloc申请空间失败");
//		return;
//	}
//	capacity = n;
//	top = 0;
//}
//int main()
//{
//	Stack st;
//	st.Init();
//	return 0;
//}

//// 声明和定义分离，需要指定类域 
//void Stack::Init(int n)
//{
//	array = (int*)malloc(sizeof(int) * n);
//	if (nullptr == array)
//	{
//		perror("malloc申请空间失败");
//		return;
//	}
//	capacity = n;
//	top = 0;
//}
//
//class Stack
//{
//public:
//	// 成员函数
//	void Init(int n = 4)
//	{
//
//	}
//
//private:
//	// 成员变量，声明
//	int* array;
//	size_t capacity;
//	size_t top;
//};
//
//int main()
//{
//	// 定义，类实例化对象
//	Stack s1;
//	s1.top = 0;//此代码错误，已被private限制
//	s1.Init();
//
//	Stack s2;
//	s1.top = 1;//此代码错误，已被private限制
//	s2.Init(100);
//
//	return 0;
//}

//class A
//{
//public:
//	void Print()
//	{
//		cout << _ch << endl;
//	}
//private:
//	char _ch;
//	int _i;
//};
//
//class B
//{
//public:
//	void Print()
//	{
//		//...
//	}
//};
//
//class C
//{};
//
//int main()
//{
//	cout << sizeof(A) << endl;
//	cout << sizeof(B) << endl;
//	cout << sizeof(C) << endl;
//
//	B b1;
//	B b2;
//	cout << &b1 << endl;
//	cout << &b2 << endl;
//
//	return 0;
//}

//class Date
//{
//public:
//	//void Init(Date* const this, int year, int month, int day)
//	void Init(int year, int month, int day)
//	{
//		cout << this << endl;
//
//		// const保护this不能修改
//		// this = nullptr;
//
//		this->_year = year;//这样写也是允许的
//		this->_month = month;
//		_day = day;
//	}
//
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	// 这里只是声明，没有开空间
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1;
//	Date d2;
//	// d1.Init(&d1, 2025, 9, 23);
//	d1.Init(2025, 9, 23);
//
//	// d2.Init(&d2, 2025, 9, 24);
//	d2.Init(2025, 9, 24);
//
//	d1.Print();
//	d2.Print();
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//class A
//{
//public:
//	void Print()
//	{
//		cout << "A::Print()" << endl;
//	}
//private:
//	int _a;
//};
//int main()
//{
//	A* p = nullptr;
//	p->Print();
//	return 0;
//}

//int main()
//{
//	A* p = nullptr;
//	//p->Print();  // call 函数地址
//
//	(*p).Print();
//
//	// 00C3210C  mov         ecx, dword ptr[p]
//	// 00C3210F  call        A::Print(0C31447h)
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//class A
//{
//public:
//	void Print()
//	{
//		cout << "A::Print()" << endl;
//		cout << _a << endl;// 等价于 this->_a，而 this 是 nullptr
//	}
//private:
//	int _a;
//};
//int main()
//{
//	A* p = nullptr;
//	p->Print();
//	return 0;
//}


#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	// 满了， 扩容 
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity *
			sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	ps->top--;
}
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
int main()
{
	ST s;
	STInit(&s);
	STPush(&s, 1);
	STPush(&s, 2);
	STPush(&s, 3);
	STPush(&s, 4);
	while (!STEmpty(&s))
	{
		printf("%d\n", STTop(&s));
		STPop(&s);
	}
	STDestroy(&s);
	return 0;
}


#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	// 成员函数 
	void Init(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
	void Pop()
	{
		assert(_top > 0);
		--_top;
	}
	bool Empty()
	{
		return _top == 0;
	}
	int Top()
	{
		assert(_top > 0);
		return _a[_top - 1];
	}
	void Destroy()
	{
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	// 成员变量 
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
int main()
{
	Stack s;
	s.Init();
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	while (!s.Empty())
	{
		printf("%d\n", s.Top());
		s.Pop();
	}
	s.Destroy();
	return 0;
}
